﻿using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace ConversionDemo;

/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
    }

    // 显示错误消息
    private void ShowError(string message)
    {
        ErrorMessage.Text = message;
    }


    // 将 HEX 转换为 float
    private void HexToFloat_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            NumberInput.Text = "";

            // 移除所有空格
            string hexInput = HexInput.Text.Trim().Replace(" ", "");

            // 补全 HEX 值为 16 个字符（8 字节）
            hexInput = hexInput.PadLeft(8, '0');

            // 检查输入长度，确保有8个有效的十六进制字符
            if (hexInput.Length == 8) // 4 bytes = 8 hex digits for a float
            {
                byte[] bytes = new byte[4];
                for (int i = 0; i < 4; i++)
                {
                    bytes[i] = Convert.ToByte(hexInput.Substring(i * 2, 2), 16);
                }

                float floatValue = BitConverter.ToSingle(bytes, 0);
                NumberInput.Text = floatValue.ToString("G");
                ErrorMessage.Text = string.Empty;
            }
            else
            {
                ShowError("Invalid HEX input length. HEX should be 8 characters.");
            }
        }
        catch (Exception ex)
        {
            ShowError("Error in conversion: " + ex.Message);
        }
    }

    private void FloatToHex_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            HexInput.Text = "";

            string numberInput = NumberInput.Text.Trim();
            if (float.TryParse(numberInput, out float floatValue))
            {
                byte[] bytes = BitConverter.GetBytes(floatValue);
                string hexValue = BitConverter.ToString(bytes)
                    .Replace("-", " "); // 将连接符 "-" 替换为一个空格
                HexInput.Text = hexValue;
                ErrorMessage.Text = string.Empty;
            }
            else
            {
                ShowError("Invalid float input.");
            }
        }
        catch (Exception ex)
        {
            ShowError("Error in conversion: " + ex.Message);
        }
    }


    private void HexToDouble_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            NumberInput.Text = "";

            // 移除所有空格
            string hexInput = HexInput.Text.Trim().Replace(" ", "");

            // 补全 HEX 值为 16 个字符（8 字节）
            hexInput = hexInput.PadLeft(8, '0');

            // 检查输入长度，确保有16个有效的十六进制字符 (8 bytes = 16 hex digits for a double)
            if (hexInput.Length == 16) // 8 bytes = 16 hex digits for a double
            {
                byte[] bytes = new byte[8];
                for (int i = 0; i < 8; i++)
                {
                    bytes[i] = Convert.ToByte(hexInput.Substring(i * 2, 2), 16);
                }

                double doubleValue = BitConverter.ToDouble(bytes, 0);
                NumberInput.Text = doubleValue.ToString("G");
                ErrorMessage.Text = string.Empty;
            }
            else
            {
                ShowError("Invalid HEX input length. HEX should be 16 characters for a double.");
            }
        }
        catch (Exception ex)
        {
            ShowError("Error in conversion: " + ex.Message);
        }
    }

    private void DoubleToHex_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            HexInput.Text = "";

            string numberInput = NumberInput.Text.Trim();
            if (double.TryParse(numberInput, out double doubleValue))
            {
                // 将 double 转换为字节数组
                byte[] bytes = BitConverter.GetBytes(doubleValue);

                // 将字节数组转换为十六进制字符串，并将连接符 "-" 替换为空格
                string hexValue = BitConverter.ToString(bytes).Replace("-", " ");

                // 显示结果
                HexInput.Text = hexValue;
                ErrorMessage.Text = string.Empty;
            }
            else
            {
                ShowError("Invalid double input.");
            }
        }
        catch (Exception ex)
        {
            ShowError("Error in conversion: " + ex.Message);
        }
    }


    private void HexToInt32_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            NumberInput.Text = "";

            // 获取输入的十六进制字符串并去掉空格
            string hexInput = HexInput.Text.Trim().Replace(" ", "");

            // 如果输入为空，提示错误
            if (string.IsNullOrEmpty(hexInput))
            {
                throw new ArgumentException("请输入有效的 HEX 值");
            }

            // 补全 HEX 值为 8 个字符（4 字节）
            hexInput = hexInput.PadLeft(8, '0');

            // 如果长度超过 8 个字符，提示错误
            if (hexInput.Length > 8)
            {
                throw new ArgumentException("HEX 值超出 int32 范围");
            }

            // 将 HEX 字符串转换为 uint
            uint uintValue = Convert.ToUInt32(hexInput, 16);

            // 检查 uint 值是否在 int32 范围内
            if (uintValue > uint.MaxValue)
            {
                throw new ArgumentException("HEX 值超出 int32 范围");
            }

            // 将 uint 转换为 int32
            //int intValue = (int)uintValue;

            // 显示结果
            NumberInput.Text = uintValue.ToString();
            ErrorMessage.Text = string.Empty; // 清空错误信息
        }
        catch (Exception ex)
        {
            ShowError("转换失败: " + ex.Message);
        }
    }

    private void Int32ToHex_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            HexInput.Text = "";

            // 获取输入的整数值
            string intInput = NumberInput.Text.Trim();

            // 如果输入为空，提示错误
            if (string.IsNullOrEmpty(intInput))
            {
                throw new ArgumentException("请输入有效的整数值");
            }

            // 将输入的字符串转换为 long（支持更大范围）
            if (!long.TryParse(intInput, out long longValue))
            {
                throw new ArgumentException("请输入有效的整数值");
            }

            // 检查值是否在 int32 范围内
            if (longValue < int.MinValue || longValue > int.MaxValue)
            {
                throw new ArgumentException("输入值超出 int32 范围");
            }

            // 将 long 转换为 int32
            int intValue = (int)longValue;

            // 将 int32 转换为 HEX 字符串
            string hexValue = intValue.ToString("X8"); // 格式化为 8 字符 HEX

            // 格式化 HEX 显示（每两个字符加一个空格）
            hexValue = string.Join(" ", Enumerable.Range(0, hexValue.Length / 2)
                                                 .Select(i => hexValue.Substring(i * 2, 2)));

            // 显示结果
            HexInput.Text = hexValue;
            ErrorMessage.Text = string.Empty; // 清空错误信息
        }
        catch (Exception ex)
        {
            ShowError("转换失败: " + ex.Message);
        }
    }



    private void HexToInt64_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            NumberInput.Text = "";

            // 获取输入的十六进制字符串并去掉空格
            string hexInput = HexInput.Text.Trim().Replace(" ", "");

            // 如果输入为空，提示错误
            if (string.IsNullOrEmpty(hexInput))
            {
                throw new ArgumentException("请输入有效的 HEX 值");
            }

            // 补全 HEX 值为 16 个字符（8 字节）
            hexInput = hexInput.PadLeft(16, '0');

            // 如果长度超过 16 个字符，截取最后 16 个字符
            if (hexInput.Length > 16)
            {
                // hexInput = hexInput.Substring(hexInput.Length - 16);
                throw new ArgumentException("HEX 值超出 int64 范围");
            }

            // 将 HEX 字符串转换为 ulong
            ulong ulongValue = Convert.ToUInt64(hexInput, 16);

            // 检查 uint 值是否在 int32 范围内
            if (ulongValue > ulong.MaxValue)
            {
                throw new ArgumentException("HEX 值超出 int32 范围");
            }

            // 显示结果
            NumberInput.Text = ulongValue.ToString();
            ErrorMessage.Text = string.Empty; // 清空错误信息
        }
        catch (Exception ex)
        {
            ShowError("转换失败: " + ex.Message);
        }
    }


    private void Int64ToHex_Click(object sender, RoutedEventArgs e)
    {
        try
        {
            HexInput.Text = "";
            // 获取输入的整数值
            string intInput = NumberInput.Text.Trim();

            // 如果输入为空，提示错误
            if (string.IsNullOrEmpty(intInput))
            {
                throw new ArgumentException("请输入有效的整数值");
            }

            // 将输入的字符串转换为 long（int64）
            if (!long.TryParse(intInput, out long longValue))
            {
                throw new ArgumentException("请输入有效的 int64 值");
            }

            // 检查值是否在 int64 范围内
            if (longValue < long.MinValue || longValue > long.MaxValue)
            {
                throw new ArgumentException("输入值超出 int64 范围");
            }

            // 将 int64 转换为 HEX 字符串
            string hexValue = longValue.ToString("X16"); // 格式化为 16 字符 HEX

            // 格式化 HEX 显示（每两个字符加一个空格）
            hexValue = string.Join(" ", Enumerable.Range(0, hexValue.Length / 2)
                                                 .Select(i => hexValue.Substring(i * 2, 2)));

            // 显示结果
            HexInput.Text = hexValue;
            ErrorMessage.Text = string.Empty; // 清空错误信息
        }
        catch (Exception ex)
        {
            ShowError("转换失败: " + ex.Message);
        }
    }



}